home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / VIDEO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-04  |  27.1 KB  |  1,180 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: VIDEO.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     internas y externas para el control de la pantalla y la visualización de
  13.     las imágenes.
  14.  
  15. ==============================================================================*/
  16.  
  17.  
  18. /*---- MODULOS USADOS --------------------------------------------------------*/
  19.  
  20. #include <stdio.h>
  21. #include <graphics.h>
  22. #include <dos.h>
  23. #include <mem.h>
  24. #include <conio.h>
  25. #include <alloc.h>
  26. #include <bios.h>
  27. #include <string.h>
  28.  
  29. #include "global.h"
  30. #include "memoria.h"
  31. #include "video.h"
  32. #include "menu.h"
  33. #include "teclas.h"
  34. #include "raton.h"
  35. #include "error.h"
  36.  
  37.  
  38. /*---- ESTRUCTURAS, CONSTANTES Y VARIABLES LOCALES AL MODULO -----------------*/
  39.  
  40.     /* dimensiones de la pantalla */
  41. static int ancho,alto;
  42.  
  43. /*---- DEFINICION DE LAS FUNCIONES INTERNAS ----------------------------------*/
  44.  
  45. void VIDEOverMONO(IMAGEN *c,int x,int y);
  46. void VIDEOverEGA(IMAGEN *c,int x,int y);
  47. void VIDEOverVGA(IMAGEN *c,int x,int y);
  48.  
  49. void VIDEOponerPaleta(char *p,int colores,int modo);
  50. void CrearPaletaGris(char *p,int colores);
  51.  
  52. void VIDEOmodoVGA(void);
  53.  
  54. char *ByteInvertir(char *b);
  55. void cambiar(char *a,char *b);
  56.  
  57. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  58.  
  59.  
  60. /*---- FUNCION: extern int VIDEOiniciar(void) ----------------------------------
  61.  
  62.     Descripción:
  63.  
  64.         Esta función inicializa el modo gráfico VGA 640x480, 16 colores
  65.         que es el modo de video del interface ofrecido por el programa.
  66.  
  67.     Retorno:
  68.  
  69.         - 1 si se inicializa
  70.         - 0 si hay error
  71.  
  72. ---- CODIGO: -----------------------------------------------------------------*/
  73.  
  74. extern int VIDEOiniciar(void)
  75. {
  76. int d=VGA,m=VGAHI;
  77.  
  78.     /* iniciar modo gráfico */
  79. registerbgidriver(EGAVGA_driver);
  80. initgraph(&d,&m,"");
  81. if(graphresult() != grOk)
  82.     return(0);
  83. return(1);
  84. }
  85.  
  86. /*---- FIN FUNCION -----------------------------------------------------------*/
  87.  
  88. /*---- FUNCION: extern void VIDEOcerrar(void) ----------------------------------
  89.  
  90.     Descripción:
  91.  
  92.         Esta función deshabilita el modo de video gráfico para volver al DOS
  93.  
  94. ---- CODIGO: -----------------------------------------------------------------*/
  95.  
  96.     /* deshabilitar video */
  97. extern void VIDEOcerrar(void)
  98. {
  99.     /* volver a modo texto */
  100. closegraph();
  101. textmode(C80);
  102. }
  103.  
  104. /*---- FIN FUNCION -----------------------------------------------------------*/
  105.  
  106. /*---- FUNCION: extern int VIDEOver(IMAGEN *c) ---------------------------------
  107.  
  108.     Descripción:
  109.  
  110.         Esta función muestra una imagen en la pantalla, usando su paleta.
  111.         Si no tiene paleta de colores, se crea una paleta de grises y se
  112.         usa.
  113.  
  114.     Parámetros:
  115.  
  116.         IMAGEN *c : puntero a la imagen
  117.  
  118.     Retorno:
  119.  
  120.         - 1 si la visualiza
  121.         - 0 si no hay imagen
  122.  
  123. ---- CODIGO: -----------------------------------------------------------------*/
  124.  
  125.     /* visualizar imagen */
  126. extern int VIDEOver(IMAGEN *c)
  127. {
  128.     /* coordenadas de visualización de la esquina superior izquierda */
  129. int x=0,y=0;
  130.     /* bandera para abandonar la visualización */
  131. char fin=0;
  132.     /* paso de visualización */
  133. int paso = 8;
  134.  
  135.     /* evento leído */
  136. struct EVENTO evento;
  137.  
  138.     /* si no hay imagen, error */
  139. if(c==NULL)
  140.     {
  141.     ERRORponer(ERRnoImagen);
  142.     return(0);
  143.     }
  144.  
  145.     /* establecer dimensiones y paleta segun el modo */
  146. switch(c->modo)
  147.     {
  148.     case VIDEOmono: ancho = 640;alto=480;
  149.     break;
  150.  
  151.     case VIDEOega: ancho = 640;alto=480;
  152.  
  153.         if(!c->haypaleta)
  154.             CrearPaletaGris(c->paleta,c->colores);
  155.         VIDEOponerPaleta(c->paleta,c->colores,VIDEOega);
  156.     break;
  157.  
  158.     case VIDEOvga: ancho = 320;alto=200;
  159.         VIDEOmodoVGA();
  160.         if(!c->haypaleta)
  161.             CrearPaletaGris(c->paleta,c->colores);
  162.         VIDEOponerPaleta(c->paleta,c->colores,VIDEOvga);
  163.     break;
  164.     };
  165.  
  166. do
  167.     {
  168.         /* visualizar imagen desde coordenadas (x,y) */
  169.     switch(c->modo)
  170.         {
  171.         case VIDEOmono:VIDEOverMONO(c,x,y);break;
  172.         case VIDEOega:VIDEOverEGA(c,x,y);break;
  173.         case VIDEOvga:VIDEOverVGA(c,x,y);break;
  174.         };
  175.  
  176.         /* leer evento para desplazamientos de la imagen */
  177.     evento = leer_evento(evento);
  178.     switch(evento.e)
  179.         {
  180.             /* salir */
  181.         case ESC:
  182.         case RATON_DCHO_ON:
  183.         case RATON_IZDO_ON:fin++;
  184.         break;
  185.  
  186.             /* tecla arriba, desplaza paso abajo */
  187.         case ARRIBA:
  188.             if((y-paso)>0) y-=paso;
  189.             else y=0;
  190.         break;
  191.             /* tecla abajo, desplaza paso arriba */
  192.         case ABAJO:
  193.             if((y+paso+alto) < c->alto) y+=paso;
  194.             else
  195.                 if(c->alto > alto) y=c->alto-alto;
  196.                 else y=0;
  197.         break;
  198.             /* tecla izquierda, desplaza paso derecha */
  199.         case IZQ:
  200.             if((x-paso)>0) x-=paso;
  201.             else x=0;
  202.         break;
  203.             /* tecla derecha, desplaza paso izquierda */
  204.         case DER:
  205.             if((x+paso+ancho) < c->ancho) x+=paso;
  206.             else
  207.                 if(c->ancho > ancho) x=c->ancho-ancho;
  208.                 else x=0;
  209.         break;
  210.             /* tecla origen, esquina superior izquierda */
  211.         case ORIGEN:
  212.             x=y=0;
  213.         break;
  214.             /* tecla fin, esquina inferior derecha */
  215.         case FIN:
  216.             if(c->ancho > ancho) x=c->ancho-ancho;
  217.             else x=0;
  218.                 if(c->alto > alto) y=c->alto-alto;
  219.                 else y=0;
  220.         break;
  221.             /* tecla pagina arriba, borde superior */
  222.         case PGARR:
  223.             y=0;
  224.         break;
  225.             /* tecla pagina abajo, borde inferior */
  226.         case PGABJ:
  227.             if(c->alto > alto) y=c->alto-alto;
  228.             else y=0;
  229.         break;
  230.             /* otro caso, continuar */
  231.         default:break;
  232.         };
  233.     }
  234. while(!fin);
  235. setgraphmode(VGAHI);
  236. return(1);
  237. }
  238.  
  239. /*---- FIN FUNCION -----------------------------------------------------------*/
  240.  
  241. /*---- FUNCION: extern IMAGEN *VIDEOvision(IMAGEN *c) --------------------------
  242.  
  243.     Descripción:
  244.  
  245.         Esta función cambia, si es posible, el modo de visualización de una imagen.
  246.  
  247.     Parámetros:
  248.  
  249.         IMAGEN *c : puntero a la imagen
  250.  
  251.     Retorno:
  252.  
  253.         Puntero a la imagen
  254.  
  255. ---- CODIGO: -----------------------------------------------------------------*/
  256.  
  257. extern IMAGEN *VIDEOvision(IMAGEN *c)
  258. {
  259.     /* imagen destino */
  260. IMAGEN *e = NULL;
  261.     /* contador */
  262. register int i;
  263.     /* buffers */
  264. char buffer[ANCHO_MAXIMO];
  265. char bufferVGA[ANCHO_MAXIMO];
  266.  
  267.      /* reservar memoria para la cabecera de trabajo */
  268. if((e=MEMreservarCAB(e))==NULL)
  269.     {
  270.     ERRORponer(ERRnoMemoria);
  271.     return(c);
  272.     }
  273.  
  274.   /* cargar cabecera de trabajo */
  275. if(c->haypaleta)
  276.     memcpy(e->paleta,c->paleta,c->colores*3);
  277. strcpy(e->nombre,c->nombre);
  278. e->ancho = c->ancho;
  279. e->alto = c->alto;
  280. e->formato = c->formato;
  281. e->colores = c->colores;
  282. e->haypaleta = c->haypaleta;
  283.  
  284. switch(c->modo)
  285.     {
  286.         /* MONO a VGA */
  287.     case VIDEOmono:
  288.         e->modo = VIDEOvga;
  289.         e->bytes = e->ancho;
  290.         e->haypaleta = 1;
  291.         if(!MEMreservar(e))
  292.             {
  293.             e =MEMliberar(e);
  294.             ERRORponer(ERRnoMemoria);
  295.             return(c);
  296.             }
  297.         memcpy(e->paleta,"\x0\x0\x0\xFF\xFF\xFF",6);
  298.         for(i=0;i<c->alto;++i)
  299.             {
  300.             MEMleer(buffer,i,c);
  301.                 /* convierte a VGA */
  302.             MONOaVGA(buffer,bufferVGA,c->ancho);
  303.                 /* escribe linea */
  304.             MEMescribir(bufferVGA,i,e);
  305.             }
  306.     break;
  307.  
  308.         /* EGA a VGA */
  309.     case VIDEOega:
  310.         e->bytes = e->ancho;
  311.         e->modo = VIDEOvga;
  312.         if(!MEMreservar(e))
  313.             {
  314.             e =MEMliberar(e);
  315.             ERRORponer(ERRnoMemoria);
  316.             return(c);
  317.             }
  318.         for(i=0;i<c->alto;++i)
  319.             {
  320.             MEMleer(buffer,i,c);
  321.                 /* convierte a VGA */
  322.             EGAaVGA(buffer,bufferVGA,c->ancho);
  323.                 /* escribe linea */
  324.             MEMescribir(bufferVGA,i,e);
  325.             }
  326.     break;
  327.  
  328.     case VIDEOvga:
  329.         if(c->colores > 16)
  330.             {
  331.             e =MEMliberar(e);
  332.             ERRORponer(ERRnoMemoria);
  333.             return(c);
  334.             }
  335.       /* VGA a EGA */
  336.         if(c->colores > 2)
  337.             {
  338.             e->bytes = DePixelsABytes(e->ancho)*4;
  339.             e->modo = VIDEOega;
  340.             if(!MEMreservar(e))
  341.                 {
  342.                 e =MEMliberar(e);
  343.                 ERRORponer(ERRnoMemoria);
  344.                 return(c);
  345.                 }
  346.             for(i=0;i<c->alto;++i)
  347.                 {
  348.                 MEMleer(bufferVGA,i,c);
  349.                     /* convierte a EGA */
  350.                 VGAaEGA(bufferVGA,buffer,c->ancho);
  351.                     /* escribe linea */
  352.                 MEMescribir(buffer,i,e);
  353.                 }
  354.             }
  355.         else
  356.                 /* VGA a MONO */
  357.             {
  358.             e->bytes = DePixelsABytes(e->ancho);
  359.             e->modo = VIDEOmono;
  360.             if(!MEMreservar(e))
  361.                 {
  362.                 e =MEMliberar(e);
  363.                 ERRORponer(ERRnoMemoria);
  364.                 return(c);
  365.                 }
  366.             for(i=0;i<c->alto;++i)
  367.                 {
  368.                 MEMleer(bufferVGA,i,c);
  369.                     /* convierte a EGA */
  370.                 VGAaMONO(bufferVGA,buffer,c->ancho);
  371.                     /* escribe linea */
  372.                 MEMescribir(buffer,i,e);
  373.                 }
  374.             }
  375.     break;
  376.     };
  377. c = MEMliberar(c);
  378. c = NULL;
  379. return(e);
  380. }
  381.  
  382. /*---- FIN FUNCION -----------------------------------------------------------*/
  383.  
  384. /*---- FUNCION: extern IMAGEN *VIDEOinvertirHorizontal(IMAGEN *c) --------------
  385.  
  386.     Descripción:
  387.  
  388.         Esta función refleja una imagen de izquierda a derecha
  389.  
  390.     Parámetros:
  391.  
  392.         IMAGEN *c : Puntero a la imagen
  393.  
  394.     Retorno:
  395.  
  396.         Puntero a la imagen
  397.  
  398. ---- CODIGO: -----------------------------------------------------------------*/
  399.  
  400. extern IMAGEN *VIDEOinvertirHorizontal(IMAGEN *c)
  401. {
  402.     /* contador */
  403. register int i;
  404.     /* buffer */
  405. char buffer[ANCHO_MAXIMO];
  406.  
  407.     /* si no hay imagen, error */
  408. if(c==NULL)
  409.     {
  410.     ERRORponer(ERRnoImagen);
  411.     return(c);
  412.     }
  413.     /* para cada línea, leerla, invertirla y escribirla */
  414. for(i=0;i<c->alto;++i)
  415.     {
  416.     MEMleer(buffer,i,c);
  417.     memcpy(buffer,VIDEOinvertirLinea(c,buffer),c->ancho);
  418.     MEMescribir(buffer,i,c);
  419.     }
  420. return(c);
  421. }
  422.  
  423. /*---- FIN FUNCION -----------------------------------------------------------*/
  424.  
  425. /*---- FUNCION: extern IMAGEN *VIDEOinvertirVertical(IMAGEN *c) ----------------
  426.  
  427.     Descripción:
  428.  
  429.         Esta función refleja una imagen de arriba a abajo
  430.  
  431.     Parámetros:
  432.  
  433.         IMAGEN *c : Puntero a la imagen
  434.  
  435.     Retorno:
  436.  
  437.         Puntero a la imagen
  438.  
  439. ---- CODIGO: -----------------------------------------------------------------*/
  440.  
  441. extern IMAGEN *VIDEOinvertirVertical(IMAGEN *c)
  442. {
  443.     /* contador */
  444. register int i;
  445.     /* buffers */
  446. char buffer1[ANCHO_MAXIMO];
  447. char buffer2[ANCHO_MAXIMO];
  448.  
  449.     /* si no hay imagen, error */
  450. if(c==NULL)
  451.     {
  452.     ERRORponer(ERRnoImagen);
  453.     return(c);
  454.     }
  455.  
  456.     /* intercambiar las líneas */
  457. for(i=0;i<c->alto/2;++i)
  458.     {
  459.     MEMleer(buffer1,i,c);
  460.     MEMleer(buffer2,c->alto-1-i,c);
  461.     MEMescribir(buffer1,c->alto-1-i,c);
  462.     MEMescribir(buffer2,i,c);
  463.     }
  464. return(c);
  465. }
  466.  
  467. /*---- FIN FUNCION -----------------------------------------------------------*/
  468.  
  469. /*---- FUNCION: extern char *VIDEOinvertirLinea(IMAGEN *c,char *linea) ---------
  470.  
  471.     Descripción:
  472.  
  473.         Esta función refleja una línea de derecha a izquierda
  474.  
  475.     Parámetros:
  476.  
  477.         IMAGEN *c : Puntero a la imagen
  478.         char *linea : puntero al buffer que guarda la línea
  479.  
  480.     Retorno:
  481.  
  482.         Puntero al buffer de la linea reflejada
  483.  
  484. ---- CODIGO: -----------------------------------------------------------------*/
  485.  
  486. extern char *VIDEOinvertirLinea(IMAGEN *c,char *linea)
  487. {
  488.     /* contadores */
  489. register int i,j;
  490.     /* fin del bucle */
  491. register int fin;
  492.     /* desplazamiento para líneas EGA */
  493. int desp;
  494. switch(c->modo)
  495.     {
  496.         /* intercambiar bytes e invertirlos */
  497.     case VIDEOmono:
  498.         fin = c->bytes/2;
  499.         for(j=0;j<fin;j++)
  500.             cambiar(ByteInvertir(linea+j),ByteInvertir(linea+c->bytes-1-j));
  501.     break;
  502.         /* intercambiar bytes e invertirlos para cada plano */
  503.     case VIDEOega:
  504.         desp = c->bytes/4;
  505.         fin = desp/2;
  506.         for(i=0;i<4;i++)
  507.             for(j = 0; j < fin; ++j)
  508.                 cambiar(ByteInvertir(linea+i*desp+j),ByteInvertir(linea+(i+1)*desp-1-j));
  509.     break;
  510.         /* intercambiar bytes */
  511.     case VIDEOvga:
  512.         fin = c->ancho/2;
  513.         for(j=0;j<=fin;j++)
  514.             cambiar(linea+j,linea+c->ancho-1-j);
  515.     break;
  516.     }
  517. return(linea);
  518. }
  519.  
  520. /*---- FIN FUNCION -----------------------------------------------------------*/
  521.  
  522. /*---- FUNCION: extern IMAGEN *IMAGENduplicar(IMAGEN *c) -----------------------
  523.  
  524.     Descripción:
  525.  
  526.         Esta función crea una copia de una imagen
  527.  
  528.     Parámetros:
  529.  
  530.         IMAGEN *c : Puntero a la imagen
  531.  
  532.     Retorno:
  533.  
  534.         Puntero a la imagen
  535.  
  536. ---- CODIGO: -----------------------------------------------------------------*/
  537.  
  538. extern IMAGEN *IMAGENduplicar(IMAGEN *c)
  539. {
  540.     /* puntero a la imagen a duplicar */
  541. IMAGEN *d=NULL;
  542.     /* buffer de línea */
  543. char buffer[ANCHO_MAXIMO];
  544.     /* contador */
  545. register int i;
  546.  
  547.     /* si no hay imagen, error */
  548. if(c==NULL)
  549.     {
  550.     ERRORponer(ERRnoImagen);
  551.     return(c);
  552.     }
  553.      /* reservar memoria para la cabecera de trabajo */
  554. if((d=MEMreservarCAB(d))==NULL)
  555.     {
  556.     ERRORponer(ERRnoMemoria);
  557.     return(NULL);
  558.     }
  559.  
  560.     /* cargar cabecera de trabajo */
  561. strcpy(d->nombre,c->nombre);
  562. d->ancho = c->ancho;
  563. d->alto = c->alto;
  564. d->bytes = c->bytes;
  565. d->formato = c->formato;
  566. d->modo = c->modo;
  567. d->colores = c->colores;
  568. d->haypaleta = c->haypaleta;
  569. if(c->haypaleta) memcpy(d->paleta,c->paleta,c->colores*3);
  570.  
  571.     /* si no hay memoria para la imagen, liberar cabecera */
  572. if(!MEMreservar(d))
  573.     {
  574.     d =MEMliberar(d);
  575.     ERRORponer(ERRnoMemoria);
  576.     return(d);
  577.     }
  578. for(i=0;i<d->alto;++i)
  579.     {
  580.     MEMleer(buffer,i,c);
  581.     MEMescribir(buffer,i,d);
  582.     }
  583. return(d);
  584. }
  585.  
  586. /*---- FIN FUNCION -----------------------------------------------------------*/
  587.  
  588. /*---- FUNCION: extern void MONOaVGA(char *mono,char *vga,int pixels) ----------
  589.  
  590.     Descripción:
  591.  
  592.         Esta función convierte una linea monocroma (1 bit/pixel)
  593.         a vga (8 bits/pixel)
  594.  
  595.     Parámetros:
  596.  
  597.         char *mono : buffer de la línea monocroma
  598.         char *vga  : buffer de la línea vga
  599.         pixels     : número de pixels de la línea
  600.  
  601. ---- CODIGO: -----------------------------------------------------------------*/
  602.  
  603. extern void MONOaVGA(char *mono,char *vga,int pixels)
  604. {
  605.     /* contador de pixels */
  606. register int i;
  607.  
  608. memset(vga,0,ANCHO_MAXIMO);
  609. for(i=0;i<pixels;++i)
  610.     if(mono[i/8] & (0x80 >> (i&7)))
  611.         vga[i]++;
  612. }
  613.  
  614. /*---- FIN FUNCION -----------------------------------------------------------*/
  615.  
  616. /*---- FUNCION: extern void VGAaMONO(char *vga,char *mono,int pixels) ----------
  617.  
  618.     Descripción:
  619.  
  620.         Esta función convierte una linea vga (8 bits/pixel)
  621.         a monocroma (1 bit/pixel)
  622.  
  623.     Parámetros:
  624.  
  625.         char *vga  : buffer de la línea vga
  626.     char *mono : buffer de la línea monocroma
  627.         pixels     : número de pixels de la línea
  628.  
  629. ---- CODIGO: -----------------------------------------------------------------*/
  630.  
  631. extern void VGAaMONO(char *vga,char *mono,int pixels)
  632. {
  633.     /* contador de pixels */
  634. register int i;
  635.  
  636. memset(mono,0,ANCHO_MAXIMO);
  637. for(i=0;i<pixels;++i)
  638.     if(vga[i])
  639.         mono[i/8] |= (0x80 >> (i & 0x07));
  640. }
  641.  
  642. /*---- FIN FUNCION -----------------------------------------------------------*/
  643.  
  644. /*---- FUNCION: extern void EGAaVGA(char *ega,char *vga,int pixels) ------------
  645.  
  646.     Descripción:
  647.  
  648.         Esta función convierte una linea ega (4 bits/pixel en 4 planos)
  649.         a vga (8 bits/pixel)
  650.  
  651.     Parámetros:
  652.  
  653.         char *ega  : buffer de la línea ega
  654.         char *vga  : buffer de la línea vga
  655.         pixels     : número de pixels de la línea
  656.  
  657. ---- CODIGO: -----------------------------------------------------------------*/
  658.  
  659. extern void EGAaVGA(char *ega,char *vga,int pixels)
  660. {
  661.     /* contadores de pixels y de planos */
  662. register int i,j;
  663.     /* desplazamiento del plano */
  664. register int plano;
  665.  
  666. plano = DePixelsABytes(pixels);
  667. memset(vga,0,ANCHO_MAXIMO);
  668. for(j=0;j<4;++j)
  669.     for(i=0;i<pixels;++i)
  670.         if( (ega[(j*plano)+(i/8)] >> (7-i&7)) & 1)
  671.             vga[i] |= 1 << j;
  672. }
  673.  
  674. /*---- FIN FUNCION -----------------------------------------------------------*/
  675.  
  676. /*---- FUNCION: extern void VGAaEGA(char *vga,char *ega,int pixels) ----------
  677.  
  678.     Descripción:
  679.  
  680.         Esta función convierte una linea vga (8 bits/pixel)
  681.         a ega (4 bits/pixel en cuatro planos)
  682.  
  683.     Parámetros:
  684.  
  685.         char *vga  : buffer de la línea vga
  686.         char *ega  : buffer de la línea ega
  687.         pixels     : número de pixels de la línea
  688.  
  689. ---- CODIGO: -----------------------------------------------------------------*/
  690.  
  691. extern void VGAaEGA(char *vga,char *ega,int pixels)
  692. {
  693.     /* contadores de pixels y de planos */
  694. register int i,j;
  695.     /* desplazamiento del plano */
  696. register int plano;
  697.  
  698. memset(ega,0,ANCHO_MAXIMO);
  699. plano = DePixelsABytes(pixels);
  700. for(j=0;j<4;++j)
  701.     for(i=0;i<pixels;++i)
  702.         if(vga[i] & (1<<j))
  703.             ega[(j*plano)+(i/8)] |= (0x80 >> (i & 0x07));
  704. }
  705.  
  706. /*---- FIN FUNCION -----------------------------------------------------------*/
  707.  
  708. /*---- FUNCION: extern void EGAdePlanoaPixel(char *fuente,             ---------
  709.                                                                                          char *destino,int pixels)
  710.  
  711.     Descripción:
  712.  
  713.         Esta función convierte una linea ega por planos a ega por pixel
  714.  
  715.     Parámetros:
  716.  
  717.         char *origen  : buffer de la línea origen
  718.         char *destino : buffer de la línea destino
  719.         pixels : número de pixels de la línea
  720.  
  721. ---- CODIGO: -----------------------------------------------------------------*/
  722.  
  723. extern void EGAdePlanoaPixel(char *fuente,char *destino,int pixels)
  724. {
  725.     /* contadores de pixels y de planos */
  726. register int i,j;
  727.     /* desplazamiento del plano */
  728. register int plano;
  729.  
  730. plano = DePixelsABytes(pixels);
  731. memset(destino,0,ANCHO_MAXIMO);
  732. for(j=0;j<4;++j)
  733.     for(i=0;i<pixels;++i)
  734.         if((fuente[(j*plano)+(i/8)] >> (7-i&7)) & 1)
  735.             destino[i>>1] |=  (0x10 << j) >> (4*(i&1));
  736. }
  737.  
  738. /*---- FIN FUNCION -----------------------------------------------------------*/
  739.  
  740. /*---- FUNCION: extern void VGAdePlanoaPixel(char *fuente,             ---------
  741.                                                                                          char *destino,int pixels)
  742.  
  743.     Descripción:
  744.  
  745.         Esta función convierte una linea vga por planos a vga por pixel
  746.  
  747.     Parámetros:
  748.  
  749.         char *origen  : buffer de la línea origen
  750.         char *destino : buffer de la línea destino
  751.         pixels : número de pixels de la línea
  752.  
  753. ---- CODIGO: -----------------------------------------------------------------*/
  754.  
  755. extern void VGAdePlanoaPixel(char *fuente,char *destino,int pixels)
  756. {
  757.     /* contadores de pixels y de planos */
  758. register int i,j;
  759.     /* desplazamiento del plano */
  760. register int plano;
  761.  
  762. plano = pixels/8;
  763. memset(destino,0,ANCHO_MAXIMO);
  764. for(j=0;j<8;++j)
  765.     for(i=0;i<pixels;++i)
  766.         if( (fuente[(j*plano)+(i/8)] >> (7-i&7)) & 1)
  767.             destino[i] |= 0x80 >> j;
  768. }
  769.  
  770. /*---- FIN FUNCION -----------------------------------------------------------*/
  771.  
  772. /*---- FUNCION: extern void VGAdePixelaPlano(char *fuente,             ---------
  773.                                                                                          char *destino,int pixels)
  774.  
  775.     Descripción:
  776.  
  777.         Esta función convierte una linea vga por pixel a vga por plano
  778.  
  779.     Parámetros:
  780.  
  781.         char *origen  : buffer de la línea origen
  782.         char *destino : buffer de la línea destino
  783.         pixels : número de pixels de la línea
  784.  
  785. ---- CODIGO: -----------------------------------------------------------------*/
  786.  
  787. extern void VGAdePixelaPlano(char *fuente,char *destino,int pixels)
  788. {
  789.     /* contadores de pixels y de planos */
  790. register int i,j;
  791.     /* desplazamiento del plano */
  792. register int plano;
  793.  
  794. memset(destino,0,ANCHO_MAXIMO);
  795. plano = pixels/8;
  796. for(j=0;j<8;++j)
  797.     for(i=0;i<pixels;++i)
  798.         if(fuente[i] & (0x80>>j))
  799.             destino[(j*plano)+(i/8)] |= (0x80 >> (i&7));
  800. }
  801.  
  802. /*---- FIN FUNCION -----------------------------------------------------------*/
  803.  
  804. /*---- FUNCION: extern char *VIDEOinvertirPaleta(char *paleta,int colores) -----
  805.  
  806.     Descripción:
  807.  
  808.         Esta función transforma una paleta RGB en BGR o viceversa
  809.  
  810.     Parámetros:
  811.  
  812.         char *paleta : puntero a la paleta
  813.         int colores : número de colores de la paleta
  814.  
  815.     Retorno:
  816.  
  817.         Paleta convertida
  818.  
  819. ---- CODIGO: -----------------------------------------------------------------*/
  820.  
  821. extern char *VIDEOinvertirPaleta(char *paleta,int colores)
  822. {
  823.     /* contador de colores */
  824. register int i;
  825.     /* puntero auxiliar a paleta */
  826. register char *p;
  827.  
  828. for(i=0,p = paleta;i<colores;++i,p+=3)
  829.     cambiar(p,p+2);
  830. return(paleta);
  831. }
  832.  
  833. /*---- FIN FUNCION -----------------------------------------------------------*/
  834.  
  835. /*---- FUNCION: extern unsigned int DepixelsABytes(unsigned int n) -------------
  836.  
  837.     Descripción:
  838.  
  839.         Esta función devuelve el número de bytes necesarios para guardar un número
  840.         de pixels usando 8 bits por pixel.
  841.  
  842.     Parámetros:
  843.  
  844.         unsigned int n : número de pixels
  845.  
  846.     Retorno:
  847.  
  848.         Número de bytes
  849.  
  850. ---- CODIGO: -----------------------------------------------------------------*/
  851.  
  852. extern unsigned int DePixelsABytes(unsigned int n)
  853. {
  854.     /* si no es múltiplo de 8 */
  855. if(n & 0x0007)
  856.     return((n >> 3)+1);
  857. else
  858.     /* si lo es */
  859.     return(n >> 3);
  860. }
  861.  
  862. /*---- FIN FUNCION -----------------------------------------------------------*/
  863.  
  864. /*---- CODIFICACION DE LAS FUNCIONES INTERNAS --------------------------------*/
  865.  
  866. /*---- FUNCION: void VIDEOverMONO(IMAGEN *c,int x,int y) -----------------------
  867.  
  868.     Descripción:
  869.  
  870.         Esta función visualiza un area de una imagen monocroma, desde un par de
  871.         coordenadas (x,y)
  872.  
  873.     Parámetros:
  874.  
  875.         IMAGEN *c : puntero a la imagen
  876.         int x : coordenada izquierda del area a visualizar
  877.         int y : coordenada superior del area a visualizar
  878.  
  879. ---- CODIGO: -----------------------------------------------------------------*/
  880.  
  881.  
  882. void VIDEOverMONO(IMAGEN *c,int x,int y)
  883. {
  884.     /* contador lineas */
  885. register int i;
  886.     /* buffer de linea */
  887. char p[ANCHO_MAXIMO];
  888.     /* lineas visibles */
  889. int lineas;
  890.  
  891.     /* limpiar linea */
  892. memset(p,0,ANCHO_MAXIMO);
  893.     /* establecer lineas visibles */
  894. lineas = (c->alto < alto) ? c->alto:alto;
  895.     /* visualizar imagen */
  896. for(i=0;i<lineas;++i)
  897.     {
  898.     MEMleer(p,y++,c);
  899.     memcpy(MK_FP(0xa000,i*80),p+x,80);
  900.     if(c->bytes < 80)
  901.         memset(MK_FP(0xa000,i*80+c->bytes),0,80-c->bytes);
  902.     }
  903.     /* limpiar el resto de la pantalla */
  904. if(lineas<alto)
  905.     memset(MK_FP(0xa000,lineas*80),0,80*(alto-lineas));
  906. }
  907.  
  908. /*---- FIN FUNCION -----------------------------------------------------------*/
  909.  
  910. /*---- FUNCION: void VIDEOverEGA(IMAGEN *c,int x,int y) ------------------------
  911.  
  912.     Descripción:
  913.  
  914.         Esta función visualiza un area de una imagen ega, desde un par de
  915.         coordenadas (x,y)
  916.  
  917.     Parámetros:
  918.  
  919.         IMAGEN *c : puntero a la imagen
  920.         int x : coordenada izquierda del area a visualizar
  921.         int y : coordenada superior del area a visualizar
  922.  
  923. ---- CODIGO: -----------------------------------------------------------------*/
  924.  
  925. void VIDEOverEGA(IMAGEN *c,int x,int y)
  926. {
  927.     /* contador de lineas */
  928. register int i;
  929.     /* contador de planos */
  930. register int j;
  931.     /* buffer de linea */
  932. char p[ANCHO_MAXIMO];
  933.     /* bytes por linea para cada plano */
  934. int bytes;
  935.     /* lineas visibles */
  936. int lineas;
  937.  
  938.     /* limpiar buffer */
  939. memset(p,0,ANCHO_MAXIMO);
  940.     /* calculo de lineas visibles */
  941. lineas = (c->alto < alto) ? c->alto:alto;
  942.     /* en cada linea de memoria hay 4 planos */
  943. bytes = (c->bytes/4 > 80) ? 80 : c->bytes/4;
  944.     /* visualizar imagen */
  945. for(i = 0; i<lineas;++i)
  946.     {
  947.         /* leer linea que contiene los 4 planos consecutivamente */
  948.     MEMleer(p,y++,c);
  949.         /* para cada plano...*/
  950.     for(j=0;j<4;j++)
  951.         {
  952.             /* seleccionar plano */
  953.         outportb(0x3c4,2);outportb(0x3c5,1<<j);
  954.             /* escribir */
  955.         memcpy(MK_FP(0xa000,i*80),p+(j*(c->bytes/4)+x/8),bytes);
  956.         if(bytes < 80)
  957.             memset(MK_FP(0xa000,i*80+bytes),0,80-bytes);
  958.         }
  959.     }
  960.  
  961.     /* limpiar el resto de la pantalla */
  962. if(lineas<alto)
  963.     for(j=0;j<4;j++)
  964.         {
  965.         outportb(0x3c4,2);outportb(0x3c5,1<<j);
  966.         memset(MK_FP(0xa000,lineas*80),0,80*(alto-lineas));
  967.         }
  968. }
  969.  
  970. /*---- FIN FUNCION -----------------------------------------------------------*/
  971.  
  972. /*---- FUNCION: void VIDEOverVGA(IMAGEN *c,int x,int y) ------------------------
  973.  
  974.     Descripción:
  975.  
  976.         Esta función visualiza un area de una imagen vga, desde un par de
  977.         coordenadas (x,y)
  978.  
  979.     Parámetros:
  980.  
  981.         IMAGEN *c : puntero a la imagen
  982.         int x : coordenada izquierda del area a visualizar
  983.         int y : coordenada superior del area a visualizar
  984.  
  985. ---- CODIGO: -----------------------------------------------------------------*/
  986.  
  987. void VIDEOverVGA(IMAGEN *c,int x,int y)
  988. {
  989.     /* contador de lineas */
  990. register int i;
  991.     /* buffer de linea */
  992. char p[ANCHO_MAXIMO];
  993.     /* lineas visibles */
  994. int lineas;
  995.  
  996.     /* calcular lineas visibles */
  997. lineas = (c->alto < alto) ? c->alto:alto;
  998.     /* limpiar buffer */
  999. memset(p,0,ANCHO_MAXIMO);
  1000.     /* visualizar imagen */
  1001. for(i = 0; i < lineas ; ++i)
  1002.     {
  1003.     MEMleer(p,y++,c);
  1004.     memcpy(MK_FP(0xa000,i*ancho),p+x,ancho);
  1005.  
  1006.     if(c->bytes < ancho)
  1007.         memset(MK_FP(0xa000,i*ancho+c->bytes),0,ancho-c->bytes);
  1008.     }
  1009.     /* limpiar el resto de la pantalla */
  1010. if(lineas<alto)
  1011.     memset(MK_FP(0xa000,lineas*ancho),0,ancho*(alto-lineas));
  1012. }
  1013.  
  1014. /*---- FIN FUNCION -----------------------------------------------------------*/
  1015.  
  1016.  
  1017. /*---- FUNCION: void VIDEOponerPaleta(char *p,int colores,int modo) ------------
  1018.  
  1019.     Descripción:
  1020.  
  1021.         Esta función establece la paleta de la imagen según el modo de vídeo
  1022.  
  1023.     Parámetros:
  1024.  
  1025.         char *p : puntero a la paleta
  1026.         int colores : número de colores de la paleta
  1027.         int modo : modo de vídeo
  1028.  
  1029. ---- CODIGO: -----------------------------------------------------------------*/
  1030.  
  1031. void VIDEOponerPaleta(char *p,int colores,int modo)
  1032. {
  1033.     /* contador de colores */
  1034. register int i;
  1035.  
  1036. switch(modo)
  1037.     {
  1038.     case VIDEOega:
  1039.         {
  1040.             /* paleta temporal */
  1041.         struct palettetype paleta;
  1042.  
  1043.             /* poner paleta */
  1044.         getpalette(&paleta);
  1045.         for(i=0;i<colores;++i)
  1046.             setrgbpalette(paleta.colors[i], p[i*3]>>2, p[i*3+1]>>2, p[i*3+2]>>2);
  1047.         }
  1048.     break;
  1049.  
  1050.     case VIDEOvga:
  1051.         {
  1052.         union REGS r;
  1053.         struct SREGS sr;
  1054.             /* paleta temporal */
  1055.         char p2[768];
  1056.  
  1057.             /* poner paleta */
  1058.         memcpy(p2,p,colores*3);
  1059.         for(i=0;i<3*colores;i++)
  1060.             *(p2+i) = (*(p2+i)) >> 2;
  1061.  
  1062.         r.x.ax = 0x1012;
  1063.         r.x.bx = 0;
  1064.         r.x.cx = colores;
  1065.         r.x.dx = FP_OFF(p2);
  1066.         sr.es= FP_SEG(p2);
  1067.         int86x(0x10,&r,&r,&sr);
  1068.         }
  1069.     break;
  1070.     }
  1071. }
  1072.  
  1073. /*---- FIN FUNCION -----------------------------------------------------------*/
  1074.  
  1075. /*---- FUNCION: void CrearPaletaGris(char *p,int colores) ----------------------
  1076.  
  1077.     Descripción:
  1078.  
  1079.         Esta función crea una paleta de grises usando un total de 256 tonalidades
  1080.  
  1081.     Parámetros:
  1082.  
  1083.         char *p : puntero a la paleta
  1084.         int colores : número de colores de la paleta
  1085.  
  1086. ---- CODIGO: -----------------------------------------------------------------*/
  1087.  
  1088. void CrearPaletaGris(char *p,int colores)
  1089. {
  1090.     /* contador y factor de gris */
  1091. register int i,factor;
  1092.  
  1093.     /* calcular factor de gris */
  1094. factor = 256/colores;
  1095.     /* crear paleta */
  1096. for(i=0;i<colores;++i)
  1097.     memset(p+i*3,i*factor,3);
  1098. }
  1099.  
  1100. /*---- FIN FUNCION -----------------------------------------------------------*/
  1101.  
  1102. /*---- FUNCION: void VIDEOmodoVGA(void) ----------------------------------------
  1103.  
  1104.     Descripción:
  1105.  
  1106.         Esta función establece el modo VGA 320x200, 256 colores para permitir la
  1107.         visualización de imágenes en modo vga
  1108.  
  1109. ---- CODIGO: -----------------------------------------------------------------*/
  1110.  
  1111. void VIDEOmodoVGA(void)
  1112. {
  1113. union REGS inregs,outregs;
  1114.  
  1115.     /* establecer modo VGA 320x200, 256 colores */
  1116. inregs.x.ax = 0x0013;
  1117. int86(0x10,&inregs,&outregs);
  1118. }
  1119.  
  1120. /*---- FIN FUNCION -----------------------------------------------------------*/
  1121.  
  1122. /*---- FUNCION: char *ByteInvertir(char *b) ------------------------------------
  1123.  
  1124.     Descripción:
  1125.  
  1126.         Esta función invierte el orden de los bits de un byte
  1127.  
  1128.     Parámetros:
  1129.  
  1130.         char *b: puntero al byte
  1131.  
  1132.     Retorno:
  1133.  
  1134.         Puntero al byte
  1135.  
  1136. ---- CODIGO: -----------------------------------------------------------------*/
  1137.  
  1138. char *ByteInvertir(char *b)
  1139. {
  1140.     /* contador */
  1141. register int i;
  1142.     /* byte temporal */
  1143. register char r=0;
  1144.  
  1145. for(i=0;i<8;++i)
  1146.     r |= (((*b>>i)&1) << (7-i));
  1147. *b=r;
  1148. return(b);
  1149. }
  1150.  
  1151. /*---- FIN FUNCION -----------------------------------------------------------*/
  1152.  
  1153. /*---- FUNCION: void cambiar(char *a,char *b) ----------------------------------
  1154.  
  1155.     Descripción:
  1156.  
  1157.         Esta función intercambia los valores de dos bytes
  1158.  
  1159.     Parámetros:
  1160.  
  1161.         char *a: puntero al primer byte
  1162.         char *b: puntero al segundo byte
  1163.  
  1164. ---- CODIGO: -----------------------------------------------------------------*/
  1165.  
  1166. void cambiar(char *a,char *b)
  1167. {
  1168.     /* variable temporal */
  1169. char aux;
  1170.  
  1171.     /* intercambio */
  1172. aux = *a;
  1173. *a = *b;
  1174. *b = aux;
  1175. }
  1176.  
  1177. /*---- FIN FUNCION -----------------------------------------------------------*/
  1178.  
  1179.  
  1180.